@realtimex/realtimex-alchemy 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RealTimeX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/realtimex-alchemy.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const args = process.argv.slice(2);
+
+// Default port
+let port = '3012';
+const portIndex = args.indexOf('--port');
+if (portIndex !== -1 && args[portIndex + 1]) {
+    port = args[portIndex + 1];
+}
+
+console.log('🚀 RealTimeX Alchemy starting...');
+console.log(`📡 Port: ${port}`);
+console.log('');
+
+// Path to compiled server
+const serverPath = join(__dirname, '..', 'dist', 'api', 'index.js');
+const distPath = join(__dirname, '..', 'dist');
+
+const server = spawn(process.execPath, [serverPath, ...args], {
+    stdio: 'inherit',
+    env: {
+        ...process.env,
+        PORT: port,
+        ELECTRON_STATIC_PATH: distPath
+    },
+});
+
+server.on('error', (error) => {
+    console.error('❌ Failed to start RealTimeX Alchemy:', error.message);
+    process.exit(1);
+});
+
+server.on('close', (code) => {
+    if (code !== 0) {
+        console.log(`\n⚠️  RealTimeX Alchemy stopped with code ${code}`);
+    }
+    process.exit(code || 0);
+});
+
+process.on('SIGINT', () => {
+    console.log('\n\n⏹️  Shutting down RealTimeX Alchemy...');
+    server.kill('SIGINT');
+});
+
+process.on('SIGTERM', () => {
+    server.kill('SIGTERM');
+});

package/dist/api/config/index.js

@@ -0,0 +1,33 @@
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+dotenv.config();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const CONFIG = {
+    PORT: process.env.PORT || 3000,
+    OLLAMA_HOST: process.env.OLLAMA_HOST || 'http://localhost:11434',
+    OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+    AGENT_BROWSER_API_KEY: process.env.AGENT_BROWSER_API_KEY,
+    DATA_DIR: path.join(process.cwd(), 'data'),
+    MAX_HISTORY_ITEMS: 50,
+    RETENTION_DAYS: 30,
+};
+export const BROWSER_PATHS = {
+    darwin: {
+        chrome: path.join(process.env.HOME || '', 'Library/Application Support/Google/Chrome/Default/History'),
+        edge: path.join(process.env.HOME || '', 'Library/Application Support/Microsoft Edge/Default/History'),
+        brave: path.join(process.env.HOME || '', 'Library/Application Support/BraveSoftware/Brave-Browser/Default/History'),
+        safari: path.join(process.env.HOME || '', 'Library/Safari/History.db'),
+    },
+    win32: {
+        chrome: path.join(process.env.LOCALAPPDATA || '', 'Google/Chrome/User Data/Default/History'),
+        edge: path.join(process.env.LOCALAPPDATA || '', 'Microsoft/Edge/User Data/Default/History'),
+        brave: path.join(process.env.LOCALAPPDATA || '', 'BraveSoftware/Brave-Browser/User Data/Default/History'),
+    },
+    linux: {
+        chrome: path.join(process.env.HOME || '', '.config/google-chrome/Default/History'),
+        brave: path.join(process.env.HOME || '', '.config/BraveSoftware/Brave-Browser/Default/History'),
+    }
+};

package/dist/api/index.js

@@ -0,0 +1,237 @@
+import express from 'express';
+import cors from 'cors';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { MinerService } from './services/MinerService.js';
+import { AlchemistService } from './services/AlchemistService.js';
+import { LibrarianService } from './services/LibrarianService.js';
+import { CONFIG } from './config/index.js';
+import { EventService } from './services/EventService.js';
+import { SupabaseService } from './services/SupabaseService.js';
+import { BrowserPathDetector } from './utils/BrowserPathDetector.js';
+import { ProcessingEventService } from './services/ProcessingEventService.js';
+import fs from 'fs';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const app = express();
+app.use(cors({ origin: '*' }));
+app.use(express.json());
+const miner = new MinerService();
+const alchemist = new AlchemistService();
+const librarian = new LibrarianService();
+const events = EventService.getInstance();
+// Health check
+app.get('/health', (req, res) => {
+    res.json({ status: 'active', platform: process.platform });
+});
+// SSE Events
+app.get('/events', (req, res) => {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    events.addClient(res);
+    req.on('close', () => events.removeClient(res));
+});
+// Helper: Get authenticated Supabase client from request
+function getAuthenticatedSupabase(req) {
+    const supabaseUrl = req.headers['x-supabase-url'];
+    const supabaseKey = req.headers['x-supabase-key'];
+    const authHeader = req.headers['authorization'];
+    const accessToken = authHeader && authHeader.startsWith('Bearer ') ? authHeader.slice(7) : undefined;
+    if (supabaseUrl && supabaseKey) {
+        return SupabaseService.createClient(supabaseUrl, supabaseKey, accessToken);
+    }
+    if (SupabaseService.isConfigured() && process.env.SUPABASE_URL && process.env.SUPABASE_ANON_KEY) {
+        return SupabaseService.createClient(process.env.SUPABASE_URL, process.env.SUPABASE_ANON_KEY, accessToken);
+    }
+    throw new Error('Supabase Configuration Missing. Please configure in Settings or add .env file.');
+}
+// Get signals
+app.get('/api/signals', async (req, res) => {
+    try {
+        const supabase = getAuthenticatedSupabase(req);
+        const signals = await librarian.getSignals(supabase);
+        res.json(signals);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// Test/Debug endpoints
+// Trigger Mining (Multi-source)
+app.post('/api/mine', async (req, res) => {
+    const processingEvents = ProcessingEventService.getInstance();
+    const syncStartTime = Date.now();
+    try {
+        const supabase = getAuthenticatedSupabase(req);
+        // Get settings for the active user using the TOKEN-SCOPED client
+        // The token determines which user's data we can see.
+        const { data: settings } = await supabase
+            .from('alchemy_settings')
+            .select('*')
+            //.eq('user_id', ...) // RLS handles this implicitly usually, but we pick the first row found
+            .limit(1)
+            .single();
+        if (!settings) {
+            throw new Error('Alchemy Engine settings not found. Please save settings in the UI first.');
+        }
+        const enabledSources = (settings.custom_browser_paths || []).filter((s) => s.enabled);
+        // Emit: Sync Starting
+        await processingEvents.log({
+            eventType: 'info',
+            agentState: 'Starting',
+            message: 'Sync starting...',
+            level: 'info',
+            metadata: {
+                is_start: true,
+                sync_mode: settings.sync_mode || 'incremental',
+                max_urls: settings.max_urls_per_sync || 50,
+                browser_sources: enabledSources.length,
+                browsers: enabledSources.map((s) => s.label).join(', ')
+            },
+            userId: settings.user_id
+        }, supabase);
+        console.log('[API] Settings loaded:', {
+            id: settings.id,
+            has_custom_paths: !!settings.custom_browser_paths,
+            raw_paths: settings.custom_browser_paths,
+            type: typeof settings.custom_browser_paths
+        });
+        // 1. Mine History (Extract)
+        const history = await miner.mineHistory(settings, supabase);
+        // 2. Analyze (Process in background with completion callback)
+        if (history.length > 0) {
+            alchemist.process(history, settings, supabase, settings.user_id, syncStartTime).catch(err => {
+                console.error("Alchemist Error:", err);
+                // Emit error completion event
+                processingEvents.log({
+                    eventType: 'error',
+                    agentState: 'Failed',
+                    message: `Sync failed: ${err.message}`,
+                    level: 'error',
+                    metadata: {
+                        is_completion: true,
+                        error: err.message
+                    },
+                    userId: settings.user_id
+                }, supabase);
+            });
+        }
+        else {
+            // No URLs to process - emit completion immediately
+            const duration = Date.now() - syncStartTime;
+            await processingEvents.log({
+                eventType: 'info',
+                agentState: 'Completed',
+                message: 'Sync completed - no new URLs found',
+                level: 'info',
+                durationMs: duration,
+                metadata: {
+                    is_completion: true,
+                    total_urls: 0,
+                    signals_found: 0,
+                    skipped: 0,
+                    errors: 0,
+                    duration_seconds: Math.round(duration / 1000)
+                },
+                userId: settings.user_id
+            }, supabase);
+        }
+        res.json({ success: true, history_count: history.length, queued: true });
+    }
+    catch (error) {
+        console.error('Mining Logic Error:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+// Browser path detection
+app.get('/api/browser-paths/detect', async (req, res) => {
+    try {
+        const detector = new BrowserPathDetector();
+        const results = detector.detectAll();
+        res.json(results);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// Browser path validation
+app.post('/api/browser-paths/validate', async (req, res) => {
+    const { path: filePath } = req.body;
+    if (!filePath) {
+        return res.status(400).json({ error: 'Path is required' });
+    }
+    try {
+        const detector = new BrowserPathDetector();
+        const result = detector.validateSQLitePath(filePath);
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.post('/api/test/analyze', async (req, res) => {
+    const { text } = req.body;
+    try {
+        let config = {
+            baseUrl: CONFIG.OLLAMA_HOST,
+            model: 'llama3',
+            apiKey: ''
+        };
+        if (SupabaseService.isConfigured()) {
+            const supabase = SupabaseService.getServiceRoleClient();
+            const { data: userData } = await supabase.rpc('get_any_user_id');
+            if (userData) {
+                const { data: settings } = await supabase
+                    .from('alchemy_settings')
+                    .select('*')
+                    .eq('user_id', userData)
+                    .single();
+                if (settings) {
+                    config = {
+                        baseUrl: settings.llm_base_url || settings.ollama_host || CONFIG.OLLAMA_HOST,
+                        model: settings.llm_model_name || 'llama3',
+                        apiKey: settings.llm_api_key || settings.openai_api_key || settings.anthropic_api_key || ''
+                    };
+                }
+            }
+        }
+        const result = await alchemist.analyzeSignal(text, config);
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// Test LLM Connection
+app.post('/api/llm/test', async (req, res) => {
+    const { baseUrl, modelName, apiKey } = req.body;
+    try {
+        const result = await alchemist.testConnection({
+            baseUrl,
+            model: modelName,
+            apiKey
+        });
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+});
+// Unified Static Assets Serving
+const staticPath = process.env.ELECTRON_STATIC_PATH || path.join(__dirname, '..', '..', 'dist');
+if (fs.existsSync(staticPath)) {
+    console.log(`[Alchemy] Serving UI from ${staticPath}`);
+    app.use(express.static(staticPath));
+    // Client-side routing fallback (Bypass path-to-regexp error in Express 5)
+    app.use((req, res, next) => {
+        if (!req.path.startsWith('/api') && !req.path.startsWith('/events')) {
+            return res.sendFile(path.join(staticPath, 'index.html'));
+        }
+        next();
+    });
+}
+const PORT = CONFIG.PORT;
+app.listen(PORT, () => {
+    console.log(`[Alchemy API] Running on port ${PORT} (${process.platform})`);
+});

package/dist/api/lib/ContentCleaner.js

@@ -0,0 +1,114 @@
+export class ContentCleaner {
+    /**
+     * Cleans content by removing noise, boilerplate, and ensuring safe tokens.
+     * Optimized for LLM processing.
+     */
+    static clean(text) {
+        if (!text)
+            return "";
+        const originalText = text;
+        // 1. Detect if content is actually HTML
+        const isHtml = /<[a-z][\s\S]*>/i.test(text);
+        if (isHtml) {
+            // Lightweight HTML -> Markdown Conversion
+            // Structure: <br>, <p> -> Newlines
+            text = text.replace(/<br\s*\/?>/gi, '\n');
+            text = text.replace(/<\/p>/gi, '\n\n');
+            text = text.replace(/<p.*?>/gi, '');
+            // Structure: Headers <h1>-<h6> -> # Title
+            text = text.replace(/<h[1-6].*?>(.*?)<\/h[1-6]>/gsi, (match, p1) => `\n# ${p1}\n`);
+            // Structure: Lists <li> -> - Item
+            text = text.replace(/<li.*?>(.*?)<\/li>/gsi, (match, p1) => `\n- ${p1}`);
+            text = text.replace(/<ul.*?>/gi, '');
+            text = text.replace(/<\/ul>/gi, '\n');
+            // Links: <a href=\"...\">text</a> -> [text](href)
+            text = text.replace(/<a\s+(?:[^>]*?\s+)?href=\"([^\"]*)\"[^>]*>(.*?)<\/a>/gsi, (match, href, content) => `[${content}](${href})`);
+            // Images: <img src=\"...\" alt=\"...\"> -> ![alt](src)
+            text = text.replace(/<img\s+(?:[^>]*?\s+)?src=\"([^\"]*)\"(?:[^>]*?\s+)?alt=\"([^\"]*)\"[^>]*>/gsi, (match, src, alt) => `![${alt}](${src})`);
+            // Style/Script removal (strictly remove content)
+            text = text.replace(/<script.*?>.*?<\/script>/gsi, '');
+            text = text.replace(/<style.*?>.*?<\/style>/gsi, '');
+            // Final Strip of remaining tags
+            text = text.replace(/<[^>]+>/g, ' ');
+            // Entity decoding (Basic)
+            text = text.replace(/&nbsp;/gi, ' ');
+            text = text.replace(/&amp;/gi, '&');
+            text = text.replace(/&lt;/gi, '<');
+            text = text.replace(/&gt;/gi, '>');
+            text = text.replace(/&quot;/gi, '"');
+            text = text.replace(/&#39;/gi, "'");
+        }
+        const lines = text.split('\n');
+        const cleanedLines = [];
+        // Patterns that usually mark the START of a reply chain or a generic footer
+        const truncationPatterns = [
+            /^On .* wrote:$/i,
+            /^From: .* <.*>$/i,
+            /^-----Original Message-----$/i,
+            /^________________________________$/i,
+            /^Sent from my iPhone$/i,
+            /^Sent from my Android$/i,
+            /^Get Outlook for/i,
+            /^--$/ // Standard signature separator
+        ];
+        // Patterns for lines that should be stripped but NOT truncate the whole email
+        const noisePatterns = [
+            /view in browser/i,
+            /click here to view/i,
+            /legal notice/i,
+            /all rights reserved/i,
+            /privacy policy/i,
+            /terms of service/i,
+            /unsubscribe/i
+        ];
+        for (let line of lines) {
+            let lineStripped = line.trim();
+            if (!lineStripped) {
+                cleanedLines.push("");
+                continue;
+            }
+            // 2. Quoted text removal (lines starting with >)
+            if (lineStripped.startsWith('>')) {
+                continue;
+            }
+            // 3. Truncation check: If we hit a reply header, we stop entirely
+            let shouldTruncate = false;
+            for (const pattern of truncationPatterns) {
+                if (pattern.test(lineStripped)) {
+                    shouldTruncate = true;
+                    break;
+                }
+            }
+            if (shouldTruncate)
+                break;
+            // 4. Noise check: Strip boilerplate lines
+            let isNoise = false;
+            if (lineStripped.length < 100) {
+                for (const pattern of noisePatterns) {
+                    if (pattern.test(lineStripped)) {
+                        isNoise = true;
+                        break;
+                    }
+                }
+            }
+            if (isNoise)
+                continue;
+            cleanedLines.push(line);
+        }
+        // Reassemble
+        text = cleanedLines.join('\n');
+        // Collapse whitespace
+        text = text.replace(/\n{3,}/g, '\n\n');
+        text = text.replace(/[ \t]{2,}/g, ' ');
+        // Safety Fallback: If cleaning stripped too much, return original text truncated
+        if (text.trim().length < 20 && originalText.trim().length > 20) {
+            return originalText.substring(0, 3000).trim();
+        }
+        // Sanitize LLM Special Tokens
+        text = text.replace(/<\|/g, '< |');
+        text = text.replace(/\|>/g, '| >');
+        text = text.replace(/\[INST\]/gi, '[ INST ]');
+        text = text.replace(/\[\/INST\]/gi, '[ /INST ]');
+        return text.trim();
+    }
+}

package/dist/api/lib/types.js

@@ -0,0 +1 @@
+export {};